home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / rex.lha / rex / m2c / Scanner.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  43KB  |  1,530 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Checks
  4. #include "Checks.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_System
  8. #include "System.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_General
  12. #include "General.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Positions
  16. #include "Positions.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_IO
  20. #include "IO.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_DynArray
  24. #include "DynArray.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Strings
  28. #include "Strings.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Source
  32. #include "Source.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Strings
  36. #include "Strings.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Texts
  40. #include "Texts.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_StringMem
  44. #include "StringMem.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Idents
  48. #include "Idents.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_Errors
  52. #include "Errors.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_ScanGen
  56. #include "ScanGen.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_Positions
  60. #include "Positions.h"
  61. #endif
  62.  
  63. #ifndef DEFINITION_Scanner
  64. #include "Scanner.h"
  65. #endif
  66.  
  67. INTEGER Scanner_TokenLength;
  68. Scanner_tScanAttribute Scanner_Attribute;
  69. struct Scanner_2 Scanner_ScanTabName;
  70. PROC Scanner_Exit;
  71.  
  72. #define SymIdent    1
  73. #define SymNumber    2
  74. #define SymString    3
  75. #define SymChar    4
  76. #define SymTargetcode    5
  77. #define SymScanner    37
  78. #define SymExport    32
  79. #define SymGlobal    6
  80. #define SymLocal    31
  81. #define SymBegin    7
  82. #define SymClose    8
  83. #define SymEof    34
  84. #define SymDefault    36
  85. #define SymDefine    9
  86. #define SymStart    10
  87. #define SymRules    11
  88. #define SymNot    30
  89. #define SymDot    12
  90. #define SymComma    13
  91. #define SymEqual    14
  92. #define SymColon    15
  93. #define SymColonMinus    35
  94. #define SymNrSign    33
  95. #define SymSlash    16
  96. #define SymBar    17
  97. #define SymPlus    18
  98. #define SymMinus    19
  99. #define SymAsterisk    20
  100. #define SymQuestion    21
  101. #define SymLParen    22
  102. #define SymRParen    23
  103. #define SymLBracket    24
  104. #define SymRBracket    25
  105. #define SymLBrace    26
  106. #define SymRBrace    27
  107. #define SymLess    28
  108. #define SymGreater    29
  109. #define BraceMissing    13
  110. #define UnclosedComment    14
  111. #define UnclosedString    16
  112. static INTEGER level;
  113. static Strings_tString string;
  114. static StringMem_tStringRef NoString;
  115. static Positions_tPosition Position;
  116. static SHORTCARD PrevState;
  117. #define yyTabSpace    8
  118. #define yyDNoState    0
  119. #define yyFileStackSize    16
  120. #define yyInitBufferSize    (1024 * 8 + 256)
  121. #define yyFirstCh    '\0'
  122. #define yyLastCh    ((CHAR)'\377')
  123. #define yyEolCh    '\n'
  124. #define yyEobCh    ((CHAR)'\177')
  125. #define yyDStateCount    165
  126. #define yyTableSize    3983
  127. #define yyEobState    47
  128. #define yyDefaultState    48
  129. #define STD    1
  130. #define targetcode    3
  131. #define set    5
  132. #define rules    7
  133. #define comment    9
  134. #define Str1    11
  135. #define Str2    13
  136. #define CStr1    15
  137. #define CStr2    17
  138. typedef SHORTCARD yyTableElmt;
  139. typedef yyTableElmt yyStateRange;
  140. typedef yyTableElmt yyTableRange;
  141. typedef struct S_1 {
  142.     yyStateRange Check, Next;
  143. } yyCombType;
  144. typedef yyCombType *yyCombTypePtr;
  145. typedef struct S_2 {
  146.     CHAR A[1000000 + 1];
  147. } *yytChBufferPtr;
  148. typedef CHAR yyChRange;
  149. static struct S_3 {
  150.     LONGCARD A[yyDStateCount + 1];
  151. } yyBasePtr;
  152. static struct S_4 {
  153.     yyStateRange A[yyDStateCount + 1];
  154. } yyDefault;
  155. static struct S_5 {
  156.     yyCombType A[yyTableSize + 1];
  157. } yyComb;
  158. static struct S_6 {
  159.     yyStateRange A[yyDStateCount + 1];
  160. } yyEobTrans;
  161. static struct S_7 {
  162.     CHAR A[yyLastCh + 1];
  163. } yyToLower, yyToUpper;
  164. static struct S_8 {
  165.     yyStateRange A[1000000 + 1];
  166. } *yyStateStack;
  167. static LONGINT yyStateStackSize;
  168. static yyStateRange yyStartState;
  169. static yyStateRange yyPreviousStart;
  170. static CHAR yyCh;
  171. static System_tFile yySourceFile;
  172. static BOOLEAN yyEof;
  173. static yytChBufferPtr yyChBufferPtr;
  174. static INTEGER yyChBufferStart;
  175. static LONGINT yyChBufferSize;
  176. static INTEGER yyChBufferIndex;
  177. static INTEGER yyBytesRead;
  178. static CARDINAL yyLineCount;
  179. static INTEGER yyLineStart;
  180. static SHORTCARD yyFileStackPtr;
  181. static struct S_9 {
  182.     struct S_10 {
  183.         System_tFile SourceFile;
  184.         BOOLEAN Eof;
  185.         yytChBufferPtr ChBufferPtr;
  186.         INTEGER ChBufferStart;
  187.         LONGINT ChBufferSize;
  188.         INTEGER ChBufferIndex;
  189.         INTEGER BytesRead;
  190.         CARDINAL LineCount;
  191.         INTEGER LineStart;
  192.     } A[yyFileStackSize - 1 + 1];
  193. } yyFileStack;
  194. static void yyInitialize ARGS(());
  195. static void yyStart ARGS((yyStateRange State));
  196. static void yyPrevious ARGS(());
  197. static void yyEcho ARGS(());
  198. static void yyLess ARGS((INTEGER n));
  199. static void yyTab ARGS(());
  200. static void yyTab1 ARGS((INTEGER a));
  201. static void yyTab2 ARGS((INTEGER a, INTEGER b));
  202. static void yyEol ARGS((INTEGER Column));
  203. static void output ARGS((CHAR c));
  204. static void unput ARGS((CHAR c));
  205. static CHAR input ARGS(());
  206. static void yyGetTables ARGS(());
  207. struct S_12 {
  208.     yyTableRange A[yyDStateCount + 1];
  209. };
  210. static CARDINAL yyGetTable ARGS((System_tFile TableFile, ADDRESS Address));
  211. static void yyErrorMessage ARGS((SHORTCARD ErrorCode));
  212. static void yyExit ARGS(());
  213.  
  214.  
  215. void Scanner_ErrorAttribute
  216. # ifdef __STDC__
  217. (CARDINAL Token, Scanner_tScanAttribute *Attribute)
  218. # else
  219. (Token, Attribute)
  220. CARDINAL Token;
  221. Scanner_tScanAttribute *Attribute;
  222. # endif
  223. {
  224.   switch (Token) {
  225.   case SymIdent:;
  226.     Attribute->U_1.V_1.Ident = Idents_NoIdent;
  227.     break;
  228.   case SymNumber:;
  229.     Attribute->U_1.V_2.Number = 0;
  230.     break;
  231.   case SymString:;
  232.     Attribute->U_1.V_3.String = NoString;
  233.     break;
  234.   case SymChar:;
  235.     Attribute->U_1.V_4.Ch = '?';
  236.     break;
  237.   case SymTargetcode:;
  238.     Texts_MakeText(&Attribute->U_1.V_5.Text);
  239.     break;
  240.   default :
  241.     break;
  242.   }
  243. }
  244.  
  245. INTEGER Scanner_GetToken
  246. # ifdef __STDC__
  247. ()
  248. # else
  249. ()
  250. # endif
  251. {
  252.   yyStateRange yyState;
  253.   yyCombTypePtr yyTablePtr;
  254.   BOOLEAN yyRestartFlag;
  255.   INTEGER yyi, yySource, yyTarget, yyChBufferFree;
  256.   Strings_tString TargetCode, String, Word;
  257.  
  258.   for (;;) {
  259.     yyState = yyStartState;
  260.     Scanner_TokenLength = 0;
  261.     for (;;) {
  262.       for (;;) {
  263.         yyTablePtr = (yyCombTypePtr)(yyBasePtr.A[yyState] + ORD(yyChBufferPtr->A[yyChBufferIndex]) * sizeof(yyCombType));
  264.         if (yyTablePtr->Check != yyState) {
  265.           yyState = yyDefault.A[yyState];
  266.           if (yyState == yyDNoState) {
  267.             goto EXIT_3;
  268.           }
  269.         } else {
  270.           yyState = yyTablePtr->Next;
  271.           INC(Scanner_TokenLength);
  272.           yyStateStack->A[Scanner_TokenLength] = yyState;
  273.           INC(yyChBufferIndex);
  274.         }
  275.       } EXIT_3:;
  276.       for (;;) {
  277.         switch (yyStateStack->A[Scanner_TokenLength]) {
  278.         case 165:;
  279.           Scanner_Attribute.Position.Line = yyLineCount;
  280.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  281.           if (level == 0) {
  282.             Texts_MakeText(&Scanner_Attribute.U_1.V_5.Text);
  283.             Strings_AssignEmpty(&TargetCode);
  284.             Position = Scanner_Attribute.Position;
  285.           } else {
  286.             Scanner_GetWord(&Word);
  287.             Strings_Concatenate(&TargetCode, &Word);
  288.           }
  289.           INC(level);
  290.           yyRestartFlag = FALSE;
  291.           goto EXIT_4;
  292.           break;
  293.         case 164:;
  294.           DEC(level);
  295.           if (level == 0) {
  296.             yyStart(PrevState);
  297.             Texts_Append(&Scanner_Attribute.U_1.V_5.Text, &TargetCode);
  298.             Scanner_Attribute.Position = Position;
  299.             return SymTargetcode;
  300.           } else {
  301.             Scanner_GetWord(&Word);
  302.             Strings_Concatenate(&TargetCode, &Word);
  303.           }
  304.           yyRestartFlag = FALSE;
  305.           goto EXIT_4;
  306.           break;
  307.         case 31:;
  308.         case 52:;
  309.         case 59:;
  310.         case 66:;
  311.           if (level > 0) {
  312.             Scanner_GetWord(&Word);
  313.             Strings_Concatenate(&TargetCode, &Word);
  314.           }
  315.           yyRestartFlag = FALSE;
  316.           goto EXIT_4;
  317.           break;
  318.         case 163:;
  319.           if (level > 0) {
  320.             Strings_Append(&TargetCode, '\t');
  321.           }
  322.           yyTab();
  323.           yyRestartFlag = FALSE;
  324.           goto EXIT_4;
  325.           break;
  326.         case 162:;
  327.           if (level > 0) {
  328.             Texts_Append(&Scanner_Attribute.U_1.V_5.Text, &TargetCode);
  329.             Strings_AssignEmpty(&TargetCode);
  330.           }
  331.           yyEol(0L);
  332.           yyRestartFlag = FALSE;
  333.           goto EXIT_4;
  334.           break;
  335.         case 32:;
  336.           if (level > 0) {
  337.             Scanner_GetWord(&Word);
  338.             Strings_Append(&TargetCode, Strings_Char(&Word, 2));
  339.           }
  340.           yyRestartFlag = FALSE;
  341.           goto EXIT_4;
  342.           break;
  343.         case 29:;
  344.           if (level > 0) {
  345.             Strings_Append(&TargetCode, '\\');
  346.           }
  347.           yyRestartFlag = FALSE;
  348.           goto EXIT_4;
  349.           break;
  350.         case 161:;
  351.           Scanner_Attribute.Position.Line = yyLineCount;
  352.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  353.           Scanner_GetWord(&String);
  354.           if (ScanGen_Language == ScanGen_C) {
  355.             yyStart(CStr1);
  356.           } else {
  357.             yyStart(Str1);
  358.           }
  359.           yyRestartFlag = FALSE;
  360.           goto EXIT_4;
  361.           break;
  362.         case 160:;
  363.           Scanner_Attribute.Position.Line = yyLineCount;
  364.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  365.           Scanner_GetWord(&String);
  366.           if (ScanGen_Language == ScanGen_C) {
  367.             yyStart(CStr2);
  368.           } else {
  369.             yyStart(Str2);
  370.           }
  371.           yyRestartFlag = FALSE;
  372.           goto EXIT_4;
  373.           break;
  374.         case 22:;
  375.         case 54:;
  376.         case 61:;
  377.         case 68:;
  378.           Scanner_GetWord(&Word);
  379.           Strings_Concatenate(&String, &Word);
  380.           yyRestartFlag = FALSE;
  381.           goto EXIT_4;
  382.           break;
  383.         case 21:;
  384.         case 55:;
  385.         case 62:;
  386.         case 69:;
  387.           Scanner_GetWord(&Word);
  388.           Strings_Concatenate(&String, &Word);
  389.           yyRestartFlag = FALSE;
  390.           goto EXIT_4;
  391.           break;
  392.         case 20:;
  393.         case 35:;
  394.         case 43:;
  395.         case 56:;
  396.         case 63:;
  397.         case 70:;
  398.           Scanner_GetWord(&Word);
  399.           Strings_Concatenate(&String, &Word);
  400.           yyRestartFlag = FALSE;
  401.           goto EXIT_4;
  402.           break;
  403.         case 19:;
  404.         case 34:;
  405.         case 42:;
  406.         case 57:;
  407.         case 64:;
  408.         case 71:;
  409.           Scanner_GetWord(&Word);
  410.           Strings_Concatenate(&String, &Word);
  411.           yyRestartFlag = FALSE;
  412.           goto EXIT_4;
  413.           break;
  414.         case 159:;
  415.           Scanner_GetWord(&Word);
  416.           Strings_Concatenate(&String, &Word);
  417.           yyEol(0L);
  418.           yyRestartFlag = FALSE;
  419.           goto EXIT_4;
  420.           break;
  421.         case 158:;
  422.           Scanner_GetWord(&Word);
  423.           Strings_Concatenate(&String, &Word);
  424.           yyEol(0L);
  425.           yyRestartFlag = FALSE;
  426.           goto EXIT_4;
  427.           break;
  428.         case 157:;
  429.           Strings_Append(&String, Strings_Char(&String, 1));
  430.           yyPrevious();
  431.           Strings_Concatenate(&TargetCode, &String);
  432.           yyRestartFlag = FALSE;
  433.           goto EXIT_4;
  434.           break;
  435.         case 156:;
  436.           Strings_Append(&String, Strings_Char(&String, 1));
  437.           yyPrevious();
  438.           Strings_Concatenate(&TargetCode, &String);
  439.           yyRestartFlag = FALSE;
  440.           goto EXIT_4;
  441.           break;
  442.         case 155:;
  443.           Strings_Append(&String, '\t');
  444.           yyTab();
  445.           yyRestartFlag = FALSE;
  446.           goto EXIT_4;
  447.           break;
  448.         case 154:;
  449.           Errors_ErrorMessage((LONGCARD)UnclosedString, (LONGCARD)Errors_Error, Scanner_Attribute.Position);
  450.           Strings_Append(&String, Strings_Char(&String, 1));
  451.           yyEol(0L);
  452.           yyPrevious();
  453.           Strings_Concatenate(&TargetCode, &String);
  454.           yyRestartFlag = FALSE;
  455.           goto EXIT_4;
  456.           break;
  457.         case 153:;
  458.           yyStart(comment);
  459.           yyRestartFlag = FALSE;
  460.           goto EXIT_4;
  461.           break;
  462.         case 23:;
  463.         case 36:;
  464.         case 53:;
  465.         case 60:;
  466.         case 67:;
  467.           yyRestartFlag = FALSE;
  468.           goto EXIT_4;
  469.           break;
  470.         case 151:;
  471.           yyPrevious();
  472.           yyRestartFlag = FALSE;
  473.           goto EXIT_4;
  474.           break;
  475.         case 150:;
  476.           Scanner_Attribute.Position.Line = yyLineCount;
  477.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  478.           PrevState = STD;
  479.           yyStart(targetcode);
  480.           return SymExport;
  481.           yyRestartFlag = FALSE;
  482.           goto EXIT_4;
  483.           break;
  484.         case 145:;
  485.           Scanner_Attribute.Position.Line = yyLineCount;
  486.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  487.           PrevState = STD;
  488.           yyStart(targetcode);
  489.           return SymGlobal;
  490.           yyRestartFlag = FALSE;
  491.           goto EXIT_4;
  492.           break;
  493.         case 139:;
  494.           Scanner_Attribute.Position.Line = yyLineCount;
  495.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  496.           PrevState = STD;
  497.           yyStart(targetcode);
  498.           return SymLocal;
  499.           yyRestartFlag = FALSE;
  500.           goto EXIT_4;
  501.           break;
  502.         case 134:;
  503.           Scanner_Attribute.Position.Line = yyLineCount;
  504.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  505.           PrevState = STD;
  506.           yyStart(targetcode);
  507.           return SymBegin;
  508.           yyRestartFlag = FALSE;
  509.           goto EXIT_4;
  510.           break;
  511.         case 129:;
  512.           Scanner_Attribute.Position.Line = yyLineCount;
  513.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  514.           PrevState = STD;
  515.           yyStart(targetcode);
  516.           return SymClose;
  517.           yyRestartFlag = FALSE;
  518.           goto EXIT_4;
  519.           break;
  520.         case 124:;
  521.           Scanner_Attribute.Position.Line = yyLineCount;
  522.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  523.           PrevState = STD;
  524.           yyStart(targetcode);
  525.           return SymDefault;
  526.           yyRestartFlag = FALSE;
  527.           goto EXIT_4;
  528.           break;
  529.         case 120:;
  530.           Scanner_Attribute.Position.Line = yyLineCount;
  531.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  532.           PrevState = STD;
  533.           yyStart(targetcode);
  534.           return SymEof;
  535.           yyRestartFlag = FALSE;
  536.           goto EXIT_4;
  537.           break;
  538.         case 117:;
  539.           Scanner_Attribute.Position.Line = yyLineCount;
  540.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  541.           return SymScanner;
  542.           yyRestartFlag = FALSE;
  543.           goto EXIT_4;
  544.           break;
  545.         case 111:;
  546.           Scanner_Attribute.Position.Line = yyLineCount;
  547.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  548.           return SymDefine;
  549.           yyRestartFlag = FALSE;
  550.           goto EXIT_4;
  551.           break;
  552.         case 105:;
  553.           Scanner_Attribute.Position.Line = yyLineCount;
  554.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  555.           return SymStart;
  556.           yyRestartFlag = FALSE;
  557.           goto EXIT_4;
  558.           break;
  559.         case 33:;
  560.         case 41:;
  561.           Scanner_Attribute.Position.Line = yyLineCount;
  562.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  563.           yyStart(rules);
  564.           return SymRules;
  565.           yyRestartFlag = FALSE;
  566.           goto EXIT_4;
  567.           break;
  568.         case 100:;
  569.           Scanner_Attribute.Position.Line = yyLineCount;
  570.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  571.           return SymNot;
  572.           yyRestartFlag = FALSE;
  573.           goto EXIT_4;
  574.           break;
  575.         case 25:;
  576.         case 39:;
  577.         case 44:;
  578.         case 45:;
  579.         case 98:;
  580.         case 99:;
  581.         case 101:;
  582.         case 102:;
  583.         case 103:;
  584.         case 104:;
  585.         case 106:;
  586.         case 107:;
  587.         case 108:;
  588.         case 109:;
  589.         case 110:;
  590.         case 112:;
  591.         case 113:;
  592.         case 114:;
  593.         case 115:;
  594.         case 116:;
  595.         case 118:;
  596.         case 119:;
  597.         case 121:;
  598.         case 122:;
  599.         case 123:;
  600.         case 125:;
  601.         case 126:;
  602.         case 127:;
  603.         case 128:;
  604.         case 130:;
  605.         case 131:;
  606.         case 132:;
  607.         case 133:;
  608.         case 135:;
  609.         case 136:;
  610.         case 137:;
  611.         case 138:;
  612.         case 140:;
  613.         case 141:;
  614.         case 142:;
  615.         case 143:;
  616.         case 144:;
  617.         case 146:;
  618.         case 147:;
  619.         case 148:;
  620.         case 149:;
  621.           Scanner_Attribute.Position.Line = yyLineCount;
  622.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  623.           Scanner_GetWord(&Word);
  624.           Scanner_Attribute.U_1.V_1.Ident = Idents_MakeIdent(&Word);
  625.           return SymIdent;
  626.           yyRestartFlag = FALSE;
  627.           goto EXIT_4;
  628.           break;
  629.         case 26:;
  630.           Scanner_Attribute.Position.Line = yyLineCount;
  631.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  632.           Scanner_GetWord(&Word);
  633.           Scanner_Attribute.U_1.V_2.Number = Strings_StringToInt(&Word);
  634.           return SymNumber;
  635.           yyRestartFlag = FALSE;
  636.           goto EXIT_4;
  637.           break;
  638.         case 30:;
  639.           Scanner_Attribute.Position.Line = yyLineCount;
  640.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  641.           Scanner_GetWord(&Word);
  642.           Strings_SubString(&Word, 2, (Strings_tStringIndex)(Strings_Length(&Word) - 1), &TargetCode);
  643.           Scanner_Attribute.U_1.V_3.String = StringMem_PutString(&TargetCode);
  644.           return SymString;
  645.           yyRestartFlag = FALSE;
  646.           goto EXIT_4;
  647.           break;
  648.         case 97:;
  649.           Scanner_Attribute.Position.Line = yyLineCount;
  650.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  651.           return SymDot;
  652.           yyRestartFlag = FALSE;
  653.           goto EXIT_4;
  654.           break;
  655.         case 96:;
  656.           Scanner_Attribute.Position.Line = yyLineCount;
  657.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  658.           return SymEqual;
  659.           yyRestartFlag = FALSE;
  660.           goto EXIT_4;
  661.           break;
  662.         case 95:;
  663.           Scanner_Attribute.Position.Line = yyLineCount;
  664.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  665.           yyPrevious();
  666.           return SymRBrace;
  667.           yyRestartFlag = FALSE;
  668.           goto EXIT_4;
  669.           break;
  670.         case 94:;
  671.           Scanner_Attribute.Position.Line = yyLineCount;
  672.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  673.           return SymMinus;
  674.           yyRestartFlag = FALSE;
  675.           goto EXIT_4;
  676.           break;
  677.         case 93:;
  678.           Scanner_Attribute.Position.Line = yyLineCount;
  679.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  680.           return SymComma;
  681.           yyRestartFlag = FALSE;
  682.           goto EXIT_4;
  683.           break;
  684.         case 92:;
  685.           Scanner_Attribute.Position.Line = yyLineCount;
  686.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  687.           return SymBar;
  688.           yyRestartFlag = FALSE;
  689.           goto EXIT_4;
  690.           break;
  691.         case 91:;
  692.           Scanner_Attribute.Position.Line = yyLineCount;
  693.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  694.           return SymPlus;
  695.           yyRestartFlag = FALSE;
  696.           goto EXIT_4;
  697.           break;
  698.         case 90:;
  699.           Scanner_Attribute.Position.Line = yyLineCount;
  700.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  701.           return SymAsterisk;
  702.           yyRestartFlag = FALSE;
  703.           goto EXIT_4;
  704.           break;
  705.         case 89:;
  706.           Scanner_Attribute.Position.Line = yyLineCount;
  707.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  708.           return SymQuestion;
  709.           yyRestartFlag = FALSE;
  710.           goto EXIT_4;
  711.           break;
  712.         case 88:;
  713.           Scanner_Attribute.Position.Line = yyLineCount;
  714.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  715.           return SymLParen;
  716.           yyRestartFlag = FALSE;
  717.           goto EXIT_4;
  718.           break;
  719.         case 87:;
  720.           Scanner_Attribute.Position.Line = yyLineCount;
  721.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  722.           return SymRParen;
  723.           yyRestartFlag = FALSE;
  724.           goto EXIT_4;
  725.           break;
  726.         case 86:;
  727.           Scanner_Attribute.Position.Line = yyLineCount;
  728.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  729.           return SymLBracket;
  730.           yyRestartFlag = FALSE;
  731.           goto EXIT_4;
  732.           break;
  733.         case 85:;
  734.           Scanner_Attribute.Position.Line = yyLineCount;
  735.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  736.           return SymRBracket;
  737.           yyRestartFlag = FALSE;
  738.           goto EXIT_4;
  739.           break;
  740.         case 84:;
  741.           Scanner_Attribute.Position.Line = yyLineCount;
  742.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  743.           yyStart(set);
  744.           return SymLBrace;
  745.           yyRestartFlag = FALSE;
  746.           goto EXIT_4;
  747.           break;
  748.         case 83:;
  749.           Scanner_Attribute.Position.Line = yyLineCount;
  750.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  751.           return SymNrSign;
  752.           yyRestartFlag = FALSE;
  753.           goto EXIT_4;
  754.           break;
  755.         case 82:;
  756.           Scanner_Attribute.Position.Line = yyLineCount;
  757.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  758.           return SymSlash;
  759.           yyRestartFlag = FALSE;
  760.           goto EXIT_4;
  761.           break;
  762.         case 81:;
  763.           Scanner_Attribute.Position.Line = yyLineCount;
  764.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  765.           return SymLess;
  766.           yyRestartFlag = FALSE;
  767.           goto EXIT_4;
  768.           break;
  769.         case 80:;
  770.           Scanner_Attribute.Position.Line = yyLineCount;
  771.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  772.           return SymGreater;
  773.           yyRestartFlag = FALSE;
  774.           goto EXIT_4;
  775.           break;
  776.         case 78:;
  777.           Scanner_Attribute.Position.Line = yyLineCount;
  778.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  779.           PrevState = rules;
  780.           yyStart(targetcode);
  781.           return SymColon;
  782.           yyRestartFlag = FALSE;
  783.           goto EXIT_4;
  784.           break;
  785.         case 79:;
  786.           Scanner_Attribute.Position.Line = yyLineCount;
  787.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  788.           PrevState = rules;
  789.           yyStart(targetcode);
  790.           return SymColonMinus;
  791.           yyRestartFlag = FALSE;
  792.           goto EXIT_4;
  793.           break;
  794.         case 77:;
  795.           Scanner_Attribute.Position.Line = yyLineCount;
  796.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  797.           Scanner_Attribute.U_1.V_4.Ch = '\n';
  798.           return SymChar;
  799.           yyRestartFlag = FALSE;
  800.           goto EXIT_4;
  801.           break;
  802.         case 76:;
  803.           Scanner_Attribute.Position.Line = yyLineCount;
  804.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  805.           Scanner_Attribute.U_1.V_4.Ch = '\t';
  806.           return SymChar;
  807.           yyRestartFlag = FALSE;
  808.           goto EXIT_4;
  809.           break;
  810.         case 75:;
  811.           Scanner_Attribute.Position.Line = yyLineCount;
  812.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  813.           Scanner_Attribute.U_1.V_4.Ch = ((CHAR)'\13');
  814.           return SymChar;
  815.           yyRestartFlag = FALSE;
  816.           goto EXIT_4;
  817.           break;
  818.         case 74:;
  819.           Scanner_Attribute.Position.Line = yyLineCount;
  820.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  821.           Scanner_Attribute.U_1.V_4.Ch = '\b';
  822.           return SymChar;
  823.           yyRestartFlag = FALSE;
  824.           goto EXIT_4;
  825.           break;
  826.         case 73:;
  827.           Scanner_Attribute.Position.Line = yyLineCount;
  828.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  829.           Scanner_Attribute.U_1.V_4.Ch = '\r';
  830.           return SymChar;
  831.           yyRestartFlag = FALSE;
  832.           goto EXIT_4;
  833.           break;
  834.         case 72:;
  835.           Scanner_Attribute.Position.Line = yyLineCount;
  836.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  837.           Scanner_Attribute.U_1.V_4.Ch = '\f';
  838.           return SymChar;
  839.           yyRestartFlag = FALSE;
  840.           goto EXIT_4;
  841.           break;
  842.         case 28:;
  843.           Scanner_Attribute.Position.Line = yyLineCount;
  844.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  845.           Scanner_GetWord(&Word);
  846.           Strings_SubString(&Word, 2, (Strings_tStringIndex)Strings_Length(&Word), &TargetCode);
  847.           Scanner_Attribute.U_1.V_4.Ch = CHR((CARDINAL)Strings_StringToInt(&TargetCode));
  848.           return SymChar;
  849.           yyRestartFlag = FALSE;
  850.           goto EXIT_4;
  851.           break;
  852.         case 27:;
  853.           Scanner_Attribute.Position.Line = yyLineCount;
  854.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  855.           Scanner_GetWord(&Word);
  856.           Scanner_Attribute.U_1.V_4.Ch = Strings_Char(&Word, 2);
  857.           return SymChar;
  858.           yyRestartFlag = FALSE;
  859.           goto EXIT_4;
  860.           break;
  861.         case 24:;
  862.         case 37:;
  863.         case 38:;
  864.         case 152:;
  865.           Scanner_Attribute.Position.Line = yyLineCount;
  866.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart - Scanner_TokenLength;
  867.           Scanner_GetWord(&Word);
  868.           Scanner_Attribute.U_1.V_4.Ch = Strings_Char(&Word, 1);
  869.           return SymChar;
  870.           yyRestartFlag = FALSE;
  871.           goto EXIT_4;
  872.           break;
  873.         case 65:;
  874.           yyRestartFlag = FALSE;
  875.           goto EXIT_4;
  876.           break;
  877.         case 58:;
  878.           yyRestartFlag = FALSE;
  879.           goto EXIT_4;
  880.           break;
  881.         case 51:;
  882.           while (yyChBufferPtr->A[yyChBufferIndex] == ' ') {
  883.             INC(yyChBufferIndex);
  884.           }
  885.           yyRestartFlag = FALSE;
  886.           goto EXIT_4;
  887.           break;
  888.         case 50:;
  889.           DEC1(yyLineStart, 7 - (yyChBufferIndex - yyLineStart - 2) % 8);
  890.           yyRestartFlag = FALSE;
  891.           goto EXIT_4;
  892.           break;
  893.         case 49:;
  894.           INC(yyLineCount);
  895.           yyLineStart = yyChBufferIndex - 1;
  896.           yyRestartFlag = FALSE;
  897.           goto EXIT_4;
  898.           break;
  899.         case 1:;
  900.         case 2:;
  901.         case 3:;
  902.         case 4:;
  903.         case 5:;
  904.         case 6:;
  905.         case 7:;
  906.         case 8:;
  907.         case 9:;
  908.         case 10:;
  909.         case 11:;
  910.         case 12:;
  911.         case 13:;
  912.         case 14:;
  913.         case 15:;
  914.         case 16:;
  915.         case 17:;
  916.         case 18:;
  917.         case 40:;
  918.         case 46:;
  919.           DEC(yyChBufferIndex);
  920.           DEC(Scanner_TokenLength);
  921.           break;
  922.         case 48:;
  923.           Scanner_Attribute.Position.Line = yyLineCount;
  924.           Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart;
  925.           INC(yyChBufferIndex);
  926.           Scanner_TokenLength = 1;
  927.           IO_WriteC((System_tFile)IO_StdOutput, yyChBufferPtr->A[yyChBufferIndex - 1]);
  928.           yyRestartFlag = FALSE;
  929.           goto EXIT_4;
  930.           break;
  931.         case yyDNoState:;
  932.           yyGetTables();
  933.           yyStateStack->A[0] = yyDefaultState;
  934.           if (yyFileStackPtr == 0) {
  935.             yyInitialize();
  936.             yySourceFile = System_StdInput;
  937.           }
  938.           yyRestartFlag = FALSE;
  939.           goto EXIT_4;
  940.           break;
  941.         case 47:;
  942.           DEC(yyChBufferIndex);
  943.           DEC(Scanner_TokenLength);
  944.           if (Scanner_TokenLength == 0) {
  945.             yyState = yyStartState;
  946.           } else {
  947.             yyState = yyStateStack->A[Scanner_TokenLength];
  948.           }
  949.           if (yyChBufferIndex != yyChBufferStart + yyBytesRead) {
  950.             yyState = yyEobTrans.A[yyState];
  951.             if (yyState != yyDNoState) {
  952.               INC(yyChBufferIndex);
  953.               INC(Scanner_TokenLength);
  954.               yyStateStack->A[Scanner_TokenLength] = yyState;
  955.               yyRestartFlag = TRUE;
  956.               goto EXIT_4;
  957.             }
  958.           } else {
  959.             yySource = yyChBufferIndex - Scanner_TokenLength - 1;
  960.             yyTarget = General_MaxAlign - Scanner_TokenLength % General_MaxAlign - 1;
  961.             if (yySource != yyTarget) {
  962.               {
  963.                 LONGINT B_1 = 1, B_2 = Scanner_TokenLength;
  964.  
  965.                 if (B_1 <= B_2)
  966.                   for (yyi = B_1;; yyi += 1) {
  967.                     yyChBufferPtr->A[yyTarget + yyi] = yyChBufferPtr->A[yySource + yyi];
  968.                     if (yyi >= B_2) break;
  969.                   }
  970.               }
  971.               DEC1(yyLineStart, yySource - yyTarget);
  972.               yyChBufferStart = yyTarget + Scanner_TokenLength + 1;
  973.             } else {
  974.               yyChBufferStart = yyChBufferIndex;
  975.             }
  976.             if (!yyEof) {
  977.               yyChBufferFree = General_Exp2(General_Log2(yyChBufferSize - 4 - General_MaxAlign - Scanner_TokenLength));
  978.               if (yyChBufferFree < yyChBufferSize / 8) {
  979.                 DynArray_ExtendArray((ADDRESS *)&yyChBufferPtr, &yyChBufferSize, (LONGINT)sizeof(CHAR));
  980.                 if (yyChBufferPtr == NIL) {
  981.                   yyErrorMessage(1);
  982.                 }
  983.                 yyChBufferFree = General_Exp2(General_Log2(yyChBufferSize - 4 - General_MaxAlign - Scanner_TokenLength));
  984.                 if (yyStateStackSize < yyChBufferSize) {
  985.                   DynArray_ExtendArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyStateRange));
  986.                   if (yyStateStack == NIL) {
  987.                     yyErrorMessage(1);
  988.                   }
  989.                 }
  990.               }
  991.               yyChBufferIndex = yyChBufferStart;
  992.               yyBytesRead = Source_GetLine(yySourceFile, ADR(yyChBufferPtr->A[yyChBufferIndex]), (LONGCARD)yyChBufferFree);
  993.               if (yyBytesRead <= 0) {
  994.                 yyBytesRead = 0;
  995.                 yyEof = TRUE;
  996.               }
  997.               yyChBufferPtr->A[yyChBufferStart + yyBytesRead] = yyEobCh;
  998.               yyChBufferPtr->A[yyChBufferStart + yyBytesRead + 1] = '\0';
  999.               yyRestartFlag = TRUE;
  1000.               goto EXIT_4;
  1001.             }
  1002.             if (Scanner_TokenLength == 0) {
  1003.               Scanner_Attribute.Position.Line = yyLineCount;
  1004.               Scanner_Attribute.Position.Column = yyChBufferIndex - yyLineStart;
  1005.               Scanner_CloseFile();
  1006.               if (yyFileStackPtr == 0) {
  1007.                 switch (yyStartState) {
  1008.                 case targetcode:;
  1009.                 case set:;
  1010.                   Errors_ErrorMessage((LONGCARD)BraceMissing, (LONGCARD)Errors_Error, Scanner_Attribute.Position);
  1011.                   break;
  1012.                 case comment:;
  1013.                   Errors_ErrorMessage((LONGCARD)UnclosedComment, (LONGCARD)Errors_Error, Scanner_Attribute.Position);
  1014.                   break;
  1015.                 case CStr1:;
  1016.                 case CStr2:;
  1017.                 case Str1:;
  1018.                 case Str2:;
  1019.                   Errors_ErrorMessage((LONGCARD)UnclosedString, (LONGCARD)Errors_Error, Scanner_Attribute.Position);
  1020.                   break;
  1021.                 default :
  1022.                   break;
  1023.                 }
  1024.                 yyStart(STD);
  1025.               }
  1026.               if (yyFileStackPtr == 0) {
  1027.                 return Scanner_EofToken;
  1028.               }
  1029.               yyRestartFlag = FALSE;
  1030.               goto EXIT_4;
  1031.             }
  1032.           }
  1033.           break;
  1034.         default :
  1035.           yyErrorMessage(0);
  1036.           break;
  1037.         }
  1038.       } EXIT_4:;
  1039.       if (yyRestartFlag) {
  1040.       } else {
  1041.         goto EXIT_2;
  1042.       }
  1043.     } EXIT_2:;
  1044.   } EXIT_1:;
  1045. }
  1046.  
  1047. void Scanner_BeginFile
  1048. # ifdef __STDC__
  1049. (CHAR FileName[], LONGCARD O_1)
  1050. # else
  1051. (FileName, O_1)
  1052. CHAR FileName[];
  1053. LONGCARD O_1;
  1054. # endif
  1055. {
  1056.   OPEN_ARRAY_LOCALS
  1057.  
  1058.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  1059.   COPY_OPEN_ARRAY(FileName, O_1, CHAR)
  1060.   if (yyStateStack->A[0] == yyDNoState) {
  1061.     yyGetTables();
  1062.     yyStateStack->A[0] = yyDefaultState;
  1063.   }
  1064.   yyInitialize();
  1065.   yySourceFile = Source_BeginSource(FileName, O_1);
  1066.   FREE_OPEN_ARRAYS
  1067. }
  1068.  
  1069. static void yyInitialize
  1070. # ifdef __STDC__
  1071. ()
  1072. # else
  1073. ()
  1074. # endif
  1075. {
  1076.   if (yyFileStackPtr >= yyFileStackSize) {
  1077.     yyErrorMessage(3);
  1078.   }
  1079.   INC(yyFileStackPtr);
  1080.   {
  1081.     register struct S_10 *W_1 = &yyFileStack.A[yyFileStackPtr - 1];
  1082.  
  1083.     W_1->SourceFile = yySourceFile;
  1084.     W_1->Eof = yyEof;
  1085.     W_1->ChBufferPtr = yyChBufferPtr;
  1086.     W_1->ChBufferStart = yyChBufferStart;
  1087.     W_1->ChBufferSize = yyChBufferSize;
  1088.     W_1->ChBufferIndex = yyChBufferIndex;
  1089.     W_1->BytesRead = yyBytesRead;
  1090.     W_1->LineCount = yyLineCount;
  1091.     W_1->LineStart = yyLineStart;
  1092.   }
  1093.   yyChBufferSize = yyInitBufferSize;
  1094.   DynArray_MakeArray((ADDRESS *)&yyChBufferPtr, &yyChBufferSize, (LONGINT)sizeof(CHAR));
  1095.   yyChBufferStart = General_MaxAlign;
  1096.   yyChBufferPtr->A[yyChBufferStart - 1] = yyEolCh;
  1097.   yyChBufferPtr->A[yyChBufferStart] = yyEobCh;
  1098.   yyChBufferPtr->A[yyChBufferStart + 1] = '\0';
  1099.   yyChBufferIndex = yyChBufferStart;
  1100.   yyEof = FALSE;
  1101.   yyBytesRead = 0;
  1102.   yyLineCount = 1;
  1103.   yyLineStart = yyChBufferStart - 1;
  1104. }
  1105.  
  1106. void Scanner_CloseFile
  1107. # ifdef __STDC__
  1108. ()
  1109. # else
  1110. ()
  1111. # endif
  1112. {
  1113.   if (yyFileStackPtr == 0) {
  1114.     yyErrorMessage(4);
  1115.   }
  1116.   Source_CloseSource(yySourceFile);
  1117.   DynArray_ReleaseArray((ADDRESS *)&yyChBufferPtr, &yyChBufferSize, (LONGINT)sizeof(CHAR));
  1118.   {
  1119.     register struct S_10 *W_2 = &yyFileStack.A[yyFileStackPtr - 1];
  1120.  
  1121.     yySourceFile = W_2->SourceFile;
  1122.     yyEof = W_2->Eof;
  1123.     yyChBufferPtr = W_2->ChBufferPtr;
  1124.     yyChBufferStart = W_2->ChBufferStart;
  1125.     yyChBufferSize = W_2->ChBufferSize;
  1126.     yyChBufferIndex = W_2->ChBufferIndex;
  1127.     yyBytesRead = W_2->BytesRead;
  1128.     yyLineCount = W_2->LineCount;
  1129.     yyLineStart = W_2->LineStart;
  1130.   }
  1131.   DEC(yyFileStackPtr);
  1132. }
  1133.  
  1134. void Scanner_GetWord
  1135. # ifdef __STDC__
  1136. (Strings_tString *Word)
  1137. # else
  1138. (Word)
  1139. Strings_tString *Word;
  1140. # endif
  1141. {
  1142.   INTEGER i, WordStart;
  1143.  
  1144.   WordStart = yyChBufferIndex - Scanner_TokenLength - 1;
  1145.   {
  1146.     LONGINT B_3 = 1, B_4 = Scanner_TokenLength;
  1147.  
  1148.     if (B_3 <= B_4)
  1149.       for (i = B_3;; i += 1) {
  1150.         Word->Chars.A[i] = yyChBufferPtr->A[WordStart + i];
  1151.         if (i >= B_4) break;
  1152.       }
  1153.   }
  1154.   Word->Length = Scanner_TokenLength;
  1155. }
  1156.  
  1157. void Scanner_GetLower
  1158. # ifdef __STDC__
  1159. (Strings_tString *Word)
  1160. # else
  1161. (Word)
  1162. Strings_tString *Word;
  1163. # endif
  1164. {
  1165.   INTEGER i, WordStart;
  1166.  
  1167.   WordStart = yyChBufferIndex - Scanner_TokenLength - 1;
  1168.   {
  1169.     LONGINT B_5 = 1, B_6 = Scanner_TokenLength;
  1170.  
  1171.     if (B_5 <= B_6)
  1172.       for (i = B_5;; i += 1) {
  1173.         Word->Chars.A[i] = yyToLower.A[yyChBufferPtr->A[WordStart + i]];
  1174.         if (i >= B_6) break;
  1175.       }
  1176.   }
  1177.   Word->Length = Scanner_TokenLength;
  1178. }
  1179.  
  1180. void Scanner_GetUpper
  1181. # ifdef __STDC__
  1182. (Strings_tString *Word)
  1183. # else
  1184. (Word)
  1185. Strings_tString *Word;
  1186. # endif
  1187. {
  1188.   INTEGER i, WordStart;
  1189.  
  1190.   WordStart = yyChBufferIndex - Scanner_TokenLength - 1;
  1191.   {
  1192.     LONGINT B_7 = 1, B_8 = Scanner_TokenLength;
  1193.  
  1194.     if (B_7 <= B_8)
  1195.       for (i = B_7;; i += 1) {
  1196.         Word->Chars.A[i] = yyToUpper.A[yyChBufferPtr->A[WordStart + i]];
  1197.         if (i >= B_8) break;
  1198.       }
  1199.   }
  1200.   Word->Length = Scanner_TokenLength;
  1201. }
  1202.  
  1203. static void yyStart
  1204. # ifdef __STDC__
  1205. (yyStateRange State)
  1206. # else
  1207. (State)
  1208. yyStateRange State;
  1209. # endif
  1210. {
  1211.   yyPreviousStart = yyStartState;
  1212.   yyStartState = State;
  1213. }
  1214.  
  1215. static void yyPrevious
  1216. # ifdef __STDC__
  1217. ()
  1218. # else
  1219. ()
  1220. # endif
  1221. {
  1222.   yyStateRange s;
  1223.  
  1224.   s = yyStartState;
  1225.   yyStartState = yyPreviousStart;
  1226.   yyPreviousStart = s;
  1227. }
  1228.  
  1229. static void yyEcho
  1230. # ifdef __STDC__
  1231. ()
  1232. # else
  1233. ()
  1234. # endif
  1235. {
  1236.   INTEGER i;
  1237.  
  1238.   {
  1239.     LONGINT B_9 = yyChBufferIndex - Scanner_TokenLength, B_10 = yyChBufferIndex - 1;
  1240.  
  1241.     if (B_9 <= B_10)
  1242.       for (i = B_9;; i += 1) {
  1243.         IO_WriteC((System_tFile)IO_StdOutput, yyChBufferPtr->A[i]);
  1244.         if (i >= B_10) break;
  1245.       }
  1246.   }
  1247. }
  1248.  
  1249. static void yyLess
  1250. # ifdef __STDC__
  1251. (INTEGER n)
  1252. # else
  1253. (n)
  1254. INTEGER n;
  1255. # endif
  1256. {
  1257.   DEC1(yyChBufferIndex, Scanner_TokenLength - n);
  1258.   Scanner_TokenLength = n;
  1259. }
  1260.  
  1261. static void yyTab
  1262. # ifdef __STDC__
  1263. ()
  1264. # else
  1265. ()
  1266. # endif
  1267. {
  1268.   DEC1(yyLineStart, yyTabSpace - 1 - (yyChBufferIndex - yyLineStart - 2) % yyTabSpace);
  1269. }
  1270.  
  1271. static void yyTab1
  1272. # ifdef __STDC__
  1273. (INTEGER a)
  1274. # else
  1275. (a)
  1276. INTEGER a;
  1277. # endif
  1278. {
  1279.   DEC1(yyLineStart, yyTabSpace - 1 - (yyChBufferIndex - yyLineStart - Scanner_TokenLength + a - 1) % yyTabSpace);
  1280. }
  1281.  
  1282. static void yyTab2
  1283. # ifdef __STDC__
  1284. (INTEGER a, INTEGER b)
  1285. # else
  1286. (a, b)
  1287. INTEGER a, b;
  1288. # endif
  1289. {
  1290.   DEC1(yyLineStart, yyTabSpace - 1 - (yyChBufferIndex - yyLineStart - Scanner_TokenLength + a - 1) % yyTabSpace);
  1291. }
  1292.  
  1293. static void yyEol
  1294. # ifdef __STDC__
  1295. (INTEGER Column)
  1296. # else
  1297. (Column)
  1298. INTEGER Column;
  1299. # endif
  1300. {
  1301.   INC(yyLineCount);
  1302.   yyLineStart = yyChBufferIndex - 1 - Column;
  1303. }
  1304.  
  1305. static void output
  1306. # ifdef __STDC__
  1307. (CHAR c)
  1308. # else
  1309. (c)
  1310. CHAR c;
  1311. # endif
  1312. {
  1313.   IO_WriteC((System_tFile)IO_StdOutput, c);
  1314. }
  1315.  
  1316. static void unput
  1317. # ifdef __STDC__
  1318. (CHAR c)
  1319. # else
  1320. (c)
  1321. CHAR c;
  1322. # endif
  1323. {
  1324.   DEC(yyChBufferIndex);
  1325.   yyChBufferPtr->A[yyChBufferIndex] = c;
  1326. }
  1327.  
  1328. static CHAR input
  1329. # ifdef __STDC__
  1330. ()
  1331. # else
  1332. ()
  1333. # endif
  1334. {
  1335.   if (yyChBufferIndex == yyChBufferStart + yyBytesRead) {
  1336.     if (!yyEof) {
  1337.       DEC1(yyLineStart, yyBytesRead);
  1338.       yyChBufferIndex = 0;
  1339.       yyChBufferStart = 0;
  1340.       yyBytesRead = Source_GetLine(yySourceFile, (ADDRESS)yyChBufferPtr, (LONGCARD)General_Exp2(General_Log2(yyChBufferSize)));
  1341.       if (yyBytesRead <= 0) {
  1342.         yyBytesRead = 0;
  1343.         yyEof = TRUE;
  1344.       }
  1345.       yyChBufferPtr->A[yyBytesRead] = yyEobCh;
  1346.       yyChBufferPtr->A[yyBytesRead + 1] = '\0';
  1347.     }
  1348.   }
  1349.   if (yyChBufferIndex == yyChBufferStart + yyBytesRead) {
  1350.     return '\0';
  1351.   } else {
  1352.     INC(yyChBufferIndex);
  1353.     return yyChBufferPtr->A[yyChBufferIndex - 1];
  1354.   }
  1355. }
  1356.  
  1357. void Scanner_BeginScanner
  1358. # ifdef __STDC__
  1359. ()
  1360. # else
  1361. ()
  1362. # endif
  1363. {
  1364.   level = 0;
  1365.   Strings_AssignEmpty(&string);
  1366.   NoString = StringMem_PutString(&string);
  1367. }
  1368.  
  1369. void Scanner_CloseScanner
  1370. # ifdef __STDC__
  1371. ()
  1372. # else
  1373. ()
  1374. # endif
  1375. {
  1376. }
  1377.  
  1378. static void yyGetTables
  1379. # ifdef __STDC__
  1380. ()
  1381. # else
  1382. ()
  1383. # endif
  1384. {
  1385.   CARDINAL BlockSize, j, n;
  1386.   System_tFile TableFile;
  1387.   yyStateRange i;
  1388.   struct S_12 Base;
  1389.  
  1390.   BlockSize = 64000 / sizeof(yyCombType);
  1391.   TableFile = OpenInput(Scanner_ScanTabName.A, 128L);
  1392.   Checks_ErrorCheck((STRING)"yyGetTables.OpenInput", 21L, TableFile);
  1393.   if (yyGetTable(TableFile, ADR(Base)) / sizeof(yyTableElmt) - 1 != yyDStateCount || yyGetTable(TableFile, ADR(yyDefault)) / sizeof(yyTableElmt) - 1 != yyDStateCount || yyGetTable(TableFile, ADR(yyEobTrans)) / sizeof(yyTableElmt) - 1 != yyDStateCount) {
  1394.     yyErrorMessage(2);
  1395.   }
  1396.   n = 0;
  1397.   j = 0;
  1398.   while (j <= yyTableSize) {
  1399.     INC1(n, yyGetTable(TableFile, ADR(yyComb.A[j])) / sizeof(yyCombType));
  1400.     INC1(j, BlockSize);
  1401.   }
  1402.   if (n != yyTableSize + 1) {
  1403.     yyErrorMessage(2);
  1404.   }
  1405.   Close(TableFile);
  1406.   for (i = 0; i <= yyDStateCount; i += 1) {
  1407.     yyBasePtr.A[i] = (LONGCARD)ADR(yyComb.A[Base.A[i]]);
  1408.   }
  1409. }
  1410.  
  1411. static CARDINAL yyGetTable
  1412. # ifdef __STDC__
  1413. (System_tFile TableFile, ADDRESS Address)
  1414. # else
  1415. (TableFile, Address)
  1416. System_tFile TableFile;
  1417. ADDRESS Address;
  1418. # endif
  1419. {
  1420.   INTEGER N;
  1421.   yyTableElmt Length;
  1422.  
  1423.   N = Read(TableFile, ADR(Length), (LONGCARD)sizeof(yyTableElmt));
  1424.   Checks_ErrorCheck((STRING)"yyGetTable.Read1", 16L, N);
  1425.   N = Read(TableFile, Address, (LONGCARD)Length);
  1426.   Checks_ErrorCheck((STRING)"yyGetTable.Read2", 16L, N);
  1427.   return Length;
  1428. }
  1429.  
  1430. static void yyErrorMessage
  1431. # ifdef __STDC__
  1432. (SHORTCARD ErrorCode)
  1433. # else
  1434. (ErrorCode)
  1435. SHORTCARD ErrorCode;
  1436. # endif
  1437. {
  1438.   Positions_WritePosition((System_tFile)IO_StdError, Scanner_Attribute.Position);
  1439.   switch (ErrorCode) {
  1440.   case 0:;
  1441.     IO_WriteS((System_tFile)IO_StdError, (STRING)": Scanner: internal error", 25L);
  1442.     break;
  1443.   case 1:;
  1444.     IO_WriteS((System_tFile)IO_StdError, (STRING)": Scanner: out of memory", 24L);
  1445.     break;
  1446.   case 2:;
  1447.     IO_WriteS((System_tFile)IO_StdError, (STRING)": Scanner: table mismatch", 25L);
  1448.     break;
  1449.   case 3:;
  1450.     IO_WriteS((System_tFile)IO_StdError, (STRING)": Scanner: too many nested include files", 40L);
  1451.     break;
  1452.   case 4:;
  1453.     IO_WriteS((System_tFile)IO_StdError, (STRING)": Scanner: file stack underflow (too many calls of CloseFile)", 61L);
  1454.     break;
  1455.   }
  1456.   IO_WriteNl((System_tFile)IO_StdError);
  1457.   (*Scanner_Exit)();
  1458. }
  1459.  
  1460. static void yyExit
  1461. # ifdef __STDC__
  1462. ()
  1463. # else
  1464. ()
  1465. # endif
  1466. {
  1467.   IO_CloseIO();
  1468.   Exit(1L);
  1469. }
  1470.  
  1471. void BEGIN_Scanner()
  1472. {
  1473.   static BOOLEAN has_been_called = FALSE;
  1474.  
  1475.   if (!has_been_called) {
  1476.     has_been_called = TRUE;
  1477.  
  1478.     BEGIN_Strings();
  1479.     BEGIN_Idents();
  1480.     BEGIN_StringMem();
  1481.     BEGIN_Texts();
  1482.     BEGIN_Positions();
  1483.     BEGIN_Checks();
  1484.     BEGIN_System();
  1485.     BEGIN_General();
  1486.     BEGIN_Positions();
  1487.     BEGIN_IO();
  1488.     BEGIN_DynArray();
  1489.     BEGIN_Strings();
  1490.     BEGIN_Source();
  1491.     BEGIN_Strings();
  1492.     BEGIN_Texts();
  1493.     BEGIN_StringMem();
  1494.     BEGIN_Idents();
  1495.     BEGIN_Errors();
  1496.     BEGIN_ScanGen();
  1497.     BEGIN_Positions();
  1498.  
  1499.     (void)strncpy((char *)Scanner_ScanTabName.A, "Scanner.Tab", sizeof(Scanner_ScanTabName.A));
  1500.     Scanner_Exit = yyExit;
  1501.     yyFileStackPtr = 0;
  1502.     yyStartState = 1;
  1503.     yyPreviousStart = 1;
  1504.     yyBasePtr.A[yyStartState] = (LONGCARD)ADR(yyComb.A[0]);
  1505.     yyDefault.A[yyStartState] = yyDNoState;
  1506.     yyComb.A[0].Check = yyDNoState;
  1507.     yyChBufferPtr = (yytChBufferPtr)ADR(yyComb.A[0]);
  1508.     yyChBufferIndex = 1;
  1509.     yyStateStackSize = yyInitBufferSize;
  1510.     DynArray_MakeArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyStateRange));
  1511.     yyStateStack->A[0] = yyDNoState;
  1512.     {
  1513.       CHAR B_11 = yyFirstCh, B_12 = yyLastCh;
  1514.  
  1515.       if (B_11 <= B_12)
  1516.         for (yyCh = B_11;; yyCh += 1) {
  1517.           yyToLower.A[yyCh] = yyCh;
  1518.           if (yyCh >= B_12) break;
  1519.         }
  1520.     }
  1521.     yyToUpper = yyToLower;
  1522.     for (yyCh = 'A'; yyCh <= 'Z'; yyCh += 1) {
  1523.       yyToLower.A[yyCh] = CHR(ORD(yyCh) - ORD('A') + ORD('a'));
  1524.     }
  1525.     for (yyCh = 'a'; yyCh <= 'z'; yyCh += 1) {
  1526.       yyToUpper.A[yyCh] = CHR(ORD(yyCh) - ORD('a') + ORD('A'));
  1527.     }
  1528.   }
  1529. }
  1530.